Skunkware 98/Skunkware 98.iso/osr5/sco/scripts/admin/news/filegroup

AWK Script | 1997-08-26 | 22.3 KB | 687 lines

#!/usr/local/bin/gawk -f
# @(#) filegroup.gawk 3.2 95/01/14
# 94/03/04 john h. dubois iii ([e-mail])
# 94/08/04 Added q & a options.  Bugfixes.
# 94/08/07 Converted to #!awk program.
# 94/08/10 Added x option.
# 94/09/22 Warn about groups with status 'n'.  Added pgt options.
#          Use status translation table.
# 94/11/09 Added -XYNS
# 94/11/16 Added multiple debug levels.  Fixed Report logic.
# 94/11/21 Added rR opts, and "r" status.
# 94/12/12 Made a option work again
# 95/01/14 Only accept legal statuses wtih -a.

# filegroup: change status of group reception
# Meaning of status:
# y: spool group
# n: spool group but do not allow posting
# x: do not spool group
# m: spool group & send postings to moderator
# =: postings to group should be spooled in a different group.
# This is extended with 'xm' to mean that group should not be spooled,
# while retaining the information that if it is changed to spooled status it
# should be moderated.

BEGIN {
    Setup(Groups,VerboseState)

    while ((GlobAct || NumGroups || Change) && (ret = (getline < active)) == 1)
    if (GlobAct || $1 in Groups) {
        if (Report)
        printf "%s %s\n",$1,VerboseState[$4]
        else if (ModifyGroup($1,$2,$3,$4,NewStatus,NewActive)) {
        Change = 1
        if (Debug > 1)
            printf "Modified specified group %s\n",$1 > "/dev/stderr"
        }
        NumGroups--
        delete Groups[$1]
    }
    else if (UseNSTable) {
        if (ModifyGroup($1,$2,$3,$4,NSTable,NewActive)) {
        Change = 1
        if (Debug > 1)
            printf "Modified non-specified group %s\n",$1 \
            > "/dev/stderr"
        }
    }
    else if (!Report)    # If not just reporting
        print $0 > NewActive

    if (ret == -1) {
    printf "Error reading active file '%s'.  Exiting.\n",
    active > "/dev/stderr"
    exit 1
    }

    if (NumGroups > 0) {
    if (Debug)
        printf "%d groups not found in active file.\n",NumElem(Groups) \
        > "/dev/stderr"
    if (CreationStatus != "") {
        for (Group in Groups)
        printf "%s 0000000000 00001 %s\n",Group,CreationStatus \
        > NewActive
        print \
        "These groups do not exist in the active file (adding them):" \
        > "/dev/stderr"
        Change = 1
    }
    else {
        print "These groups do not exist in the active file:" \
        > "/dev/stderr"
    }
    for (Group in Groups)
        print Group > "/dev/stderr"
    }
    if (Debug)
    printf "Change=%d\n",Change > "/dev/stderr"
    if (Change && !Report && !Test)
    system("a=" active "; chmod 664 $a+ && chgrp news $a+ &&"\
    " chown news $a+ && ln $a $a- && mv $a+ $a")
    exit 0
}

# Sets globals:
# active    Active file name
# NewActive    Name of new active file.
# Quiet        Do not warn about groups that were already on.
# CreationStatus    Status of groups to be added to active file.
# Debug        Debugging level.
# Report    Whether group status should be reported only.
# NumGroups    Number of groups to process.
# GlobAct    Act on all newsgroups.
# Test        Do not move new active file into place.
# UseNSTable    Use the NSTable for groups not specified.
# NewStatus[]    Translation table from old status -> new status
# NSTable[]    Translation table for groups not specified.
# Groups[]    Names of groups to process.
# VerboseState[]    Name for each possible state.
function Setup(Groups,VerboseState,  Name,Usage) {
    Name = "filegroup"
    Usage = \
"Usage: " Name  " [-hnxydqgt] [-d<debug-level>] [-a<status>] [-A<active-file>]\n"\
"                 [-s<translation-table> [newsgroup ...]"
    active = "/usr/lib/news/active"
    Report = 1
    # Opts normally uses -x to turn on debugging; removed that code.
    ARGC = Opts(Name,Usage,"a:d>A:ghnrqs:txyXYNRS:",0)

    if ("h" in Options) {
    printf \
"%s: display or change status of newsgroup reception.\n"\
"%s\n"\
"If no flags are given, %s displays the reception status of the named\n"\
"newsgroups.\n"\
"If no newsgroups are named, the standard input is read for group names.\n"\
"Options:\n"\
"-a<status>: Add any groups that do not exist in the active file, with the\n"\
"    given status (y, n, or x).  Note that this will be incorrect for any\n"\
"    groups that should be moderated.\n"\
"-g: Act on all groups.  No group names should be given with this option.\n"\
"-A<active-file>: Use <active-file> instead of %s.\n"\
"-t: Test.  Leave updated active file in active-file-name+; do not move it\n"\
"    in place of the original file.\n"\
"-h: Print this help.\n"\
"-x: Turn off reception of the named newsgroups.  y and n are changed to x,\n"\
"    m is changed to xm.\n"\
"-y: Turn on reception of the named newsgroups.  x and n are changed to y,\n"\
"    xm is changed to m.\n"\
"-n: Mark the newsgroups as local posting disallowed.  y is changed to n.\n"\
"-r: Remove the named newsgroups from the active file.\n"\
"-s<translation-table>: Give a specific status translation table, in the\n"\
"    form old=new[:old=new...], where each old=new pair gives a new status\n"\
"    that each group with the old status should be set to.  A new status of\n"\
"    'r' means that groups with the given old status will be removed from\n"\
"    the active file.\n"\
"-[XYNRS]: Like -[xynrs], but act on groups *not* named.  One of these can\n"\
"    be used to set the \"default\" reception status at the same time that\n"\
"    one of -[xynrs] is used to set a specific status for the named groups.\n"\
"-d<debug-level>: Turn on debugging.  1 prints minimal debugging info;\n"\
"    2 prints per-group debugging info.\n"\
"-q: Do not warn about groups whose status is not changed.\n",
    Name,Usage,Name,active
    exit 0
    }
    Quiet = "q" in Options
    if ((CreationStatus = Options["a"]) != "") {
    if (CreationStatus !~ /^([ynmx]|xm)$/) {
        printf "Bad status '%s' given with -a.  Exiting.\n",
        CreationStatus > "/dev/stderr"
        exit 1
    }
    else
        Report = 0
    }
    if ("d" in Options)
    Debug = Options["d"]
    Test = "t" in Options

    if ((GlobAct = ("g" in Options)) && ARGC > 1) {
    print "No group names should be given with -g.  Exiting.\n" \
    > "/dev/stderr"
    exit 1
    }

    if ("A" in Options)
    active = Options["A"]
    NewActive = active "+"

    if (!GlobAct) {
    if (ARGC > 1) {
        for (i = 1; i < ARGC; i++)
        Groups[ARGV[i]]
    }
    else
        while (getline < "/dev/stdin" == 1)
        MakeSet(Groups,$0,FS)
    delete Groups[""]

    # Do not rely on the return value of MakeSet,
    # since groups might be named more than once.
    NumGroups = NumElem(Groups)
    if (!NumGroups) {
        printf "%s: No groups specified.\n",Name > "/dev/stderr"
        exit 1
    }
    }

    InitArr(VerboseState,"x:m:xm:y:n:r","not spooled:moderated:"\
    "not spooled (moderated):spooled:spooled (local posting disabled):"\
    "removed from active",":")

    Report = \
    MakeTable(NewStatus,"x","y","n","r","s",Options,VerboseState) && Report
    UseNSTable = !MakeTable(NSTable,"X","Y","N","R","S",Options,VerboseState)
    Report = !UseNSTable && Report
    if (Debug)
    printf "Report=%d  Test=%d  GlobAct=%d\n",Report,Test,GlobAct \
    > "/dev/stderr"
}

# Returns 0 if any of x y n r s is in Options, else returns 1.
function MakeTable(Table,x,y,n,r,s,Options,States,
Report,Pair,Pairs,Elem,i,Type) {
    Report = 1

    if (x == "X")
    Type = "non-"

    if (y in Options) {
    Table["x"] = "y"
    Table["n"] = "y"
    Table["xm"] = "m"
    Report--
    }
    if (x in Options) {
    Table["y"] = "x"
    Table["n"] = "x"
    Table["m"] = "xm"
    Report--
    }
    if (n in Options) {
    Table["y"] = "n"
    Report--
    }
    if (r in Options) {
    Table["y"] = "r"
    Table["n"] = "r"
    Table["m"] = "r"
    Table["x"] = "r"
    Table["xm"] = "r"
    Report--
    }
    if (s in Options) {
    split(Options[s],Pairs,":")
    for (Pair in Pairs) {
        if (split(Pairs[Pair],Elem,"=") != 2) {
        printf "Bad format in -%s translation table.\n",
        s > "/dev/stderr"
        exit 1
        }
        if (!(Elem[1] in States) || !(Elem[2] in States)) {
        printf \
"Unknown state in -%s translation table; must be one of [x m xm y n r]\n",s \
    > "/dev/stderr"
        exit 1
        }
        Table[Elem[1]] = Elem[2]
    }
    Report--
    }
    if (Debug) {
    printf "Status translation table for %sspecified groups:\n",
    Type > "/dev/stderr"
    for (i in Table)
        printf "%s -> %s\n",i,Table[i] > "/dev/stderr"
    }
    if (Report < 0) {
    printf "Error in new status for %sspecified groups:"\
    " must give only one of -[%s%s%s%s].\n",Type,x,y,n,s > "/dev/stderr"
    exit 1
    }
    return Report
}

# Return value: 0 if no change, 1 if status changed.
# Writes a line for group Group to file NewActive.
# The first three fields of the line written are Group, c1, and c2.
# The 4th field is the translation for Status.
function ModifyGroup(Group,c1,c2,Status,XTable,NewActive,
NewState) {
    if (!(Status in XTable)) {
    if (Quiet != 1)
        printf "%s not modified; had status: %s\n",Group,
        Status in VerboseState ? VerboseState[Status] : Status \
        > "/dev/stderr"
    print Group " " c1 " " c2 " " Status > NewActive
    return 0
    }
    else {
    NewState = XTable[Status]
    printf "%s: %s -> %s\n",Group,VerboseState[Status],
    VerboseState[NewState] > "/dev/stderr"
    if (NewState != "r")
        printf "%s %s %s %s\n",Group,c1,c2,NewState > NewActive
    return 1
    }
}

# InitArr: Initialize an array with values.
# Ind and Vals are separated into lists on Sep.
# For each item in Ind, an index with that name is created in Arr[],
# and the value with the same position in Vals is stored in it.
# Global variables: none.
function InitArr(Arr,Ind,Vals,sep,  numind,indnames,values) {
    split(Ind,indnames,sep)
    split(Vals,values,sep)
    for (numind in indnames)
    Arr[indnames[numind]] = values[numind]
}

function ClearArr(Arr,  Elem) {
    for (Elem in Arr)
    delete Arr[Elem]
}
# Subtract the values in Subtrahend from those in Minuend
function SubtractArr(Minuend,Subtrahend,  Elem) {
    for (Elem in Subtrahend)
    Minuend[Elem] -= Subtrahend[Elem]
}

# For each element of the array In, an element is created in Out having
# an index equal to the value of the element in In and a value equal to
# the index of the element in In.
function Invert(In,Out,Index) {
    for (Index in In)
    Out[In[Index]] = Index
}

# Assign: make an array from a list of assignments.
# An index with the name of each variable in the list is created in the array.
# Its value is set to the value given for the
# Input variables:
# Elements is a string containing the list of variable-value pairs.
# Sep is the string that separates the pairs in the list.
# AssignOp is the string that separates variables from values.
# Output variables:
# Arr is the array.
# Return value: the number of elements added to the set.
# Example:
# Assign(Arr,"foo=blot bar=blat baz=blit"," ","=")
function Assign(Arr,Elements,Sep,AssignOp,
Num,Names,Elem,Assignments,Assignment) {
    Num = split(Elements,Assignments,Sep)
    for (; Num; Num--) {
    Assignment = Assignments[Num]
    Ind = index(Assignment,AssignOp)
    Arr[substr(Assignment,1,Ind - 1)] = substr(Assignment,Ind + 1)
    }
    return Num
}

# Returns 1 if Set is empty, 0 if not.
function IsEmpty(Set,  i) {
    for (i in Set)
    return 0
    return 1
}

# MakeSet: make a set from a list.
# An index with the name of each element of the list
# is created in the given array.
# Input variables:
# Elements is a string containing the list of elements.
# Sep is the character that separates the elements of the list.
# Output variables:
# Set is the array.
# Return value: the number of elements added to the set.
function MakeSet(Set,Elements,Sep,  i,Num,Names) {
    Num = split(Elements,Names,Sep)
    for (i = 1; i <= Num; i++)
    Set[Names[i]]
    return Num
}

# Returns the number of elements in set Set
function NumElem(Set,  elem,Num) {
    for (elem in Set)
    Num++
    return Num
}

# Note: removed the code that treats -x specially from InitOpts()
# so that -x can be used as a regular option for filegroup.

# @(#) ProcArgs 1.2.2 94/09/23
# 92/02/29 john h. dubois iii ([e-mail])
# 93/07/18 Added "#" arg type
# 93/09/26 Do not count -h against MinArgs
# 94/01/01 Stop scanning at first non-option arg.  Added ">" option type.
#          Removed meaning of "+" or "-" by itself.
# 94/03/08 Added & option and *()< option types.
# 94/04/02 Added NoRCopt to Opts()
# 94/06/11 Mark numeric variables as such.
# 94/07/08 Opts(): Don't require any args if 'h' option is given.
# 94/09/23 Fixed bug that caused fail if -opt<value> given as last arg.

# optlist is a string which contains all of the possible command line options.
# A character followed by certain characters indicates that the option takes
# an argument, with type as follows:
# :    String argument
# *    Floating point argument
# (    Non-negative floating point argument
# )    Positive floating point argument
# #    Integer argument
# <    Non-negative integer argument
# >    Positive integer argument
# The only difference the type of argument makes is in the runtime argument
# error checking that is done.

# The & option is a special case used to get numeric options without the
# user having to give an option character.  It is shorthand for [-+.0-9].
# If & is included in optlist and an option string that begins with one of
# these characters is seen, the value given to "&" will include the first
# char of the option.  & must be followed by a type character other than ":".
# Note that if e.g. &> is given, an option of -.5 will produce an error.

# Strings in argv[] which begin with "-" or "+" are taken to be
# strings of options, except that a string which consists solely of "-"
# or "+" is taken to be a non-option string; like other non-option strings,
# it stops the scanning of argv and is left in argv[].
# An argument of "--" or "++" also stops the scanning of argv[] but is removed.
# If an option takes an argument, the argument may either immediately
# follow it or be given separately.
# "-" and "+" options are treated the same.  "+" is allowed because most awks
# take any -options to be arguments to themselves.  gawk 2.15 was enhanced to
# stop scanning when it encounters an unrecognized option, though until 2.15.5
# this feature had a bug that caused problems in some cases.

# If an option that does not take an argument is given,
# an index with its name is created in Options and its value is set to "1".
# If an option that does take an argument is given,
# an index with its name is created in Options and its value
# is set to the value of the argument given for it.
# Options and their arguments are deleted from argv.
# Note that this means that there may be gaps left in the indices of argv[].
# If compress is nonzero, argv[] is packed by moving its elements so that
# they have contiguous integer indices starting with 0.
# argv[0] is not examined.
# The number of arguments left in argc is returned.
# If an error occurs, the global string OptErr is set to an error message
# and -1 is returned.
function ProcArgs(argc,argv,OptList,Options,compress,
ArgNum,ArgsLeft,Arg,ArgLen,ArgInd,Option,Pos,NumOpt,Value,HadValue,
NeedNextOpt,GotValue)
{
# ArgNum is the index of the argument being processed.
# ArgsLeft is the number of arguments left in argv.
# Arg is the argument being processed.
# ArgLen is the length of the argument being processed.
# ArgInd is the position of the character in Arg being processed.
# Option is the character in Arg being processed.
# Pos is the position in OptList of the option being processed.
# NumOpt is true if a numeric option may be given.
    ArgsLeft = argc
    NumOpt = index(OptList,"&")
    for (ArgNum = 1; ArgNum < argc; ArgNum++) {
    if ((Arg = argv[ArgNum]) !~ /^[-+]./)    # Not an option; quit
        break
    delete argv[ArgNum]
    ArgsLeft--
    if ((Arg == "--") || (Arg == "++"))
        break
    ArgLen = length(Arg)
    for (ArgInd = 2; ArgInd <= ArgLen; ArgInd++) {
        Option = substr(Arg,ArgInd,1)
        if (NumOpt && Option ~ /[-+.0-9]/) {
        Option = "&"
        Arg = "&" Arg
        ArgLen++
        Pos = NumOpt
        }
        else if (!(Pos = index(OptList,Option)) || Option == "&") {
        OptErr = "Invalid option: -" Option
        return -1
        }

        # Find what the value of the option will be if it needs one
        # NeedNextOpt is true if the option specifier is the last char of
        # this arg, which means that if the option requires a value it is
        # the next arg.
        if (NeedNextOpt = (ArgInd >= ArgLen)) { # Value is the next arg
        if (GotValue = ArgNum + 1 < argc)
            Value = argv[ArgNum+1]
        }
        else {    # Value is included with option
        Value = substr(Arg,ArgInd + 1)
        GotValue = 1
        }

        if (HadValue = AssignVal(Option,Value,Options,
        substr(OptList,Pos + 1,1),GotValue)) {
        if (HadValue == -1)
            return -1
        if (NeedNextOpt) {
            delete argv[++ArgNum]
            ArgsLeft--
        }
        break    # Used up this option
        }
    }
    }
    if (compress != 0)
    PackArr(argv,ArgsLeft)
    return ArgsLeft
}

# Global variables: OptErr
# Return value: -1 on error, 0 if option did not require an argument,
# 1 if it did.
function AssignVal(Option,Value,Options,ArgType,GotValue,Name,
UsedValue,Err) {
    # If option takes a value...
    if (UsedValue = (ArgType ~ "[:*()#<>]")) {
    if (!GotValue) {
        if (Name != "")
        OptErr = "Variable requires a value -- " Name
        else
        OptErr = "option requires an argument -- " Option
        return -1
    }
    if ((Err = CheckType(ArgType,Value,Option,Name)) != "") {
        OptErr = Err
        return -1
    }
    # Mark this as a numeric variable; will be propogated to Options[] val.
    if (ArgType != ":")
        Value += 0
    }
    else
    Value = 1
    if (!(Option in Options))    # Do not overwrite previously assigned values
    Options[Option] = Value
    return UsedValue
}

# Option is the option letter
# Value is the value being assigned
# Name is the var name of the option, if any
# ArgType is one of:
# :    String argument
# *    Floating point argument
# (    Non-negative floating point argument
# )    Positive floating point argument
# #    Integer argument
# <    Non-negative integer argument
# >    Positive integer argument
# Returns null on success, err string on error
function CheckType(ArgType,Value,Option,Name,  Err) {
    if (ArgType == ":")
    return ""
    # A number begins with option + or -, and is followed by a string of
    # digits or a decimal with digits before it, after it, or both
    if (Value !~ /^[-+]?([0-9]+|[0-9]+?\.[0-9]+|[0-9]+\.)$/)
    Err = "must be a number"
    else if (ArgType ~ "[#<>]" && Value ~ /\./)
    Err = "may not include a fraction"
    else if (ArgType ~ "[()<>]" && Value < 0)
    Err = "may not be negative"
    else if (ArgType ~ "[)>]" && Value == 0)
    Err = "must be a positive number"
    if (Err != "") {
    if (Name != "")
        return "Value assigned to variable " Name " " Err
    else {
        if (Option == "&")
        Option = Value
        return "Value assigned to option -" Option " " Err
    }
    }
    else
    return ""
}

# Packs Arr to indices starting with 0
# Num should be the number of elements in Arr
function PackArr(Arr,Num,  NewInd,OldInd) {
    NewInd = OldInd = 0
    for (; Num; Num--) {
    while (!(OldInd in Arr))
        OldInd++
    if (NewInd != OldInd) {
        Arr[NewInd] = Arr[OldInd]
        delete Arr[OldInd]
    }
    OldInd++
    NewInd++
    }
}

# Note: only the above functions are needed by ProcArgs.
# The rest of these functions call ProcArgs() and also do other
# option-processing stuff.

# Opts: Process command line arguments.
# Opts processes command line arguments using ProcArgs()
# and checks for errors.  If an error occurs, a message is printed
# and the program is exited.
#
# Input variables:
# Name is the name of the program, for error messages.
# Usage is a usage message, for error messages.
# OptList the option description string, as used by ProcArgs().
# MinArgs is the minimum number of non-option arguments that this
# program should have, non including ARGV[0] and +h.
# If the program does not require any non-option arguments,
# MinArgs should be omitted or given as 0.
# rcFile, if given, is the name of a file to read for variable initialization.
# Values given in it will not override values given on the command line.
# VarNames is a comma-separated list of variable names to map to options,
# in the same order as the options are given in OptList.
# If UseEnv is given and nonzero, the variables will also be searched for in
# the environment.  Values given in the environment will override those given
# in the rcfile but not those given on the command line.
# NoRCopt, if given, is an additional letter option that if given on the
# command line prevents the rcfile from being read.
# Special options:
# If x is made an option and is given, some debugging info is output.
# h is assumed to be the help option.

# Global variables:
# The command line arguments are taken from ARGV[].
# The arguments that are option specifiers and values are removed from
# ARGV[], leaving only ARGV[0] and the non-option arguments.
# The number of elements in ARGV[] should be in ARGC.
# After processing, ARGC is set to the number of elements left in ARGV[].
# The option values are put in Options[].
# On error, Err is set to 1 so it can be checked for in an END block.

# Return value: The number of elements left in ARGV is returned.

function Opts(Name,Usage,OptList,MinArgs,rcFile,VarNames,UseEnv,NoRCopt,
ArgsLeft) {
    if (MinArgs == "")
    MinArgs = 0
    ArgsLeft = ProcArgs(ARGC,ARGV,OptList NoRCopt,Options,1)
#    if ((ArgsLeft + ("h" in Options)) < (MinArgs+1)) {
    if (ArgsLeft < (MinArgs+1) && !("h" in Options)) {
    if (ArgsLeft != -1)
        OptErr = "Not enough arguments"
    print Name ": " OptErr ".  Use -h for help."
    print Usage
    Err = 1
    exit 1
    }
    if (rcFile != "" && (NoRCopt == "" || !(NoRCopt in Options)) &&
    InitOpts(rcFile,Options,OptList,VarNames,UseEnv) == -1)
    {
    print Name ": " OptErr ".  Use -h for help."
    Err = 1
    exit 1
    }
    return ArgsLeft
}

# Global vars: sets OptErr; uses ENVIRON[];
# if anything is read from the rcFile, sets READ_RCFILE to 1
function InitOpts(rcFile,Options,OptTypes,VarNames,UseEnv,
Line,Var,Pos,Vars,Map,CharOpt,NumVars,TypesInd,Types,Type,Ret) {
    NumVars = split(VarNames,Vars,",")
    TypesInd = Ret = 0
    for (i = 1; i <= NumVars; i++) {
    Var = Vars[i]
    CharOpt = substr(OptTypes,++TypesInd,1)
    if (CharOpt ~ "^[:*()#<>&]$")
        CharOpt = substr(OptTypes,++TypesInd,1)
    Map[Var] = CharOpt
    Types[Var] = Type = substr(OptTypes,TypesInd+1,1)
    # Do not overwrite entries from environment
    if (UseEnv && Var in ENVIRON && AssignVal(CharOpt,ENVIRON[Var],Options,
    Type,1,Var) == -1)
        return -1
    }
    if (rcFile ~ "^~/")
    rcFile = ENVIRON["HOME"] substr(rcFile,2)
    while ((getline Line < rcFile) == 1) {
    READ_RCFILE = 1
    if (Line !~ /^#/ && Line !~ "^[ \t]*$") {
        if (Pos = index(Line,"="))
        Var = substr(Line,1,Pos-1)
        else
        Var = Line    # If no value, var is entire line
        if (Var in Map) {
        if (AssignVal(Map[Var],substr(Line,Pos+1),Options,
        Types[Var],Pos != 0,Var) == -1)
            return -1
        }
        else {
        OptErr = sprintf("Unknown var \"%s\" set in %s",Var,rcFile)
        Ret = -1
        }
    }
    }
    return Ret
}